Delphi Informant Complete 1995 - 2000/Delphi Informant Complete 1995 to 2000.iso/Delphi Informant Magazine Complete Works SOURCE CODE 1998.rar/1998/May/di9805gk/DSMinMax.pas

Pascal/Delphi Source File | 1998-01-23 | 10KB | 397 lines

{
  DesignSystems
  Copyright (c) 1996-1998 all rights reserved

  Please contact [e-mail] with questions or comments
}

{$I dsinclud.inc}

unit DSMinMax;

interface

uses
  SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls,
  Forms, Dialogs;

type
  TDSMinMax = class(TComponent)
  private
    { Private declarations }
    { We use the following to keep track of which sizes we're controlling
      and what these sizes are... }
    FMaxSizeAssigned      : boolean;
    FMaxSize              : TPoint;
    FMaxPositionAssigned  : boolean;
    FMaxPosition          : Tpoint;
    FMinTrackSizeAssigned : boolean;
    FMinTrackSize         : TPoint;
    FMaxTrackSizeAssigned : boolean;
    FMaxTrackSize         : TPoint;

    { These are necessary to handle window subclassing }
    FOldWndProcForm       : TFarProc;
    FOwnerOnShow          : TNotifyEvent;
    FParentForm           : TForm;
    FWindowProcedureForm  : TFarProc;

    { A bunch of assessor functions: Get & Set }
    procedure SetMaxSize(const p: TPoint);
    procedure SetMaxPosition(const p: TPoint);
    procedure SetMinTrackSize(const p: TPoint);
    procedure SetMaxTrackSize(const p: TPoint);

    function  GetMaxPositionY: integer;
    function  GetMaxPositionX: integer;
    function  GetMaxSizeX: integer;
    function  GetMaxSizeY: integer;
    function  GetMaxTrackSizeX: integer;
    function  GetMaxTrackSizeY: integer;
    function  GetMinTrackSizeX: integer;
    function  GetMinTrackSizeY: integer;
    procedure SetMaxPositionX(const x: integer);
    procedure SetMaxPositionY(const y: integer);
    procedure SetMaxSizeX(const x: integer);
    procedure SetMaxSizeY(const y: integer);
    procedure SetMaxTrackSizeX(const x: Integer);
    procedure SetMaxTrackSizeY(const y: Integer);
    procedure SetMinTrackSizeX(const x: Integer);
    procedure SetMinTrackSizeY(const y: Integer);

    { The important functions for subclassing }
    procedure HookForm;
    procedure UnhookForm;
    procedure WndProcForm(var msg: TMessage);

  protected
    { Protected declarations }
    procedure OwnerShow(Sender: TObject);
    procedure UpdateParentSize;

  public
    { Public declarations }
    constructor Create(AOwner: TComponent);
      override;
    destructor Destroy;
      override;

    property MaxSize: TPoint
      read  FMaxSize
      write SetMaxSize;

    property MaxPosition: TPoint
      read  FMaxPosition
      write SetMaxPosition;

    property MinTrackSize: TPoint
      read  FMinTrackSize
      write SetMinTrackSize;

    property MaxTrackSize: TPoint
      read  FMaxTrackSize
      write SetMaxTrackSize;

  published
    { Published declarations }
    property MaxHeight: Integer
      read  GetMaxSizeY
      write SetMaxSizeY
      default 0;

    property MaxLeft: Integer
      read  GetMaxPositionX
      write SetMaxPositionX
      default 0;

    property MaxTop: Integer
      read  GetMaxPositionY
      write SetMaxPositionY
      default 0;

    property MaxWidth: Integer
      read  GetMaxSizeX
      write SetMaxSizeX
      default 0;

    property ResizeMaxHeight: Integer
      read  GetMaxTrackSizeY
      write SetMaxTrackSizeY
      default 0;

    property ResizeMaxWidth: Integer
      read  GetMaxTrackSizeX
      write SetMaxTrackSizeX
      default 0;

    property ResizeMinHeight: Integer
      read  GetMinTrackSizeY
      write SetMinTrackSizeY
      default 0;

    property ResizeMinWidth: Integer
      read  GetMinTrackSizeX
      write SetMinTrackSizeX
      default 0;
  end;

procedure Register;

implementation

{$IFDEF WIN32}
{$R dsminm32.dcr}
{$ELSE}
{$R dsminm16.dcr}
{$ENDIF}

constructor TDSMinMax.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);

  if not (csDesigning in ComponentState) then begin
    { If we're running in an application (as opposed to sitting on
      a form in design mode, then take over! }

    { Save my parent to make code easier to read }
    FParentForm := (Owner as TForm);

    { Catch form show }
    FOwnerOnShow := FParentForm.OnShow;
    FParentForm.OnShow := OwnerShow;
  end;
end;

destructor TDSMinMax.Destroy;
begin
  { Stop interfering ... }
  UnhookForm;

  inherited Destroy;
end;

function  TDSMinMax.GetMaxPositionX: integer;
begin
  Result := FMaxPosition.x;
end;

function  TDSMinMax.GetMaxPositionY: integer;
begin
  Result := FMaxPosition.y;
end;

function  TDSMinMax.GetMaxSizeX: integer;
begin
  Result := FMaxSize.X;
end;

function  TDSMinMax.GetMaxSizeY: integer;
begin
  Result := FMaxSize.Y;
end;

function  TDSMinMax.GetMaxTrackSizeX: integer;
begin
  Result := FMaxTrackSize.X;
end;

function  TDSMinMax.GetMaxTrackSizeY: integer;
begin
  Result := FMaxTrackSize.Y;
end;

function  TDSMinMax.GetMinTrackSizeX: integer;
begin
  Result := FMinTrackSize.X;
end;

function  TDSMinMax.GetMinTrackSizeY: integer;
begin
  Result := FMinTrackSize.Y;
end;

procedure TDSMinMax.HookForm;
begin
  { Hook the windows procedure of my owner only if I have an owner and
   its window handle has been created }
  if assigned(FParentForm) and FParentForm.HandleAllocated then begin
    { Create the window procedure from one of my methods; be sure to
      pair this with a call to FreeObjectInstance }
    FWindowProcedureForm := MakeObjectInstance(WndProcForm);

    { Subclass my form's window by inserting my window procedure into
      the message chain }
    FOldWndProcForm := TFarProc(SetWindowLong(FParentForm.Handle, gwl_WndProc,
      LongInt(FWindowProcedureForm)));
  end;
end;

procedure TDSMinMax.OwnerShow(Sender: TObject);
begin
  { My owner is being shown, that means it has a window handle and
    we can subclass it. }
   HookForm;

  { Take care of the original show, if any }
  if assigned(FOwnerOnShow) then begin
    FOwnerOnShow(Sender);
    (Owner as TForm).OnShow := FOwnerOnShow;
    FOwnerOnShow := nil;
  end;

  { Make sure that the window gets another chance to process wm_GetMinMaxInfo }
  UpdateParentSize;
end;

procedure TDSMinMax.SetMaxPositionX(const x: integer);
begin
  SetMaxPosition(Point(x, FMaxPosition.y));
end;

procedure TDSMinMax.SetMaxPositionY(const y: integer);
begin
  SetMaxPosition(Point(FMaxPosition.x, y));
end;

procedure TDSMinMax.SetMaxSizeX(const x: integer);
begin
  SetMaxSize(Point(x, FMaxSize.y));
end;

procedure TDSMinMax.SetMaxSizeY(const y: integer);
begin
  SetMaxSize(Point(FMaxSize.X, y));
end;

procedure TDSMinMax.SetMaxTrackSizeX(const x: Integer);
begin
  SetMaxTrackSize(Point(x, FMaxTrackSize.Y));
end;

procedure TDSMinMax.SetMaxTrackSizeY(const y: Integer);
begin
  SetMaxTrackSize(Point(FMaxTrackSize.X, y));
end;

procedure TDSMinMax.SetMinTrackSizeX(const x: Integer);
begin
  SetMinTrackSize(Point(x, FMinTrackSize.Y));
end;

procedure TDSMinMax.SetMinTrackSizeY(const y: Integer);
begin
  SetMinTrackSize(Point(FMinTrackSize.X, y));
end;

procedure TDSMinMax.SetMaxPosition(const p: TPoint);
begin
  if not ((p.x = FMaxPosition.x) and (p.y = FMaxPosition.y)) then
    FMaxPositionAssigned := (p.x <> 0) or (p.y <> 0);

  FMaxPosition          := p;
  UpdateParentSize;
end;

procedure TDSMinMax.SetMaxSize(const p: TPoint);
begin
  if not ((p.x = FMaxSize.x) and (p.y = FMaxSize.y)) then
    FMaxSizeAssigned := (p.x <> 0) or (p.y <> 0);

  FMaxSize := p;
  UpdateParentSize;
end;

procedure TDSMinMax.SetMaxTrackSize(const p: TPoint);
begin
  if not ((p.x = FMaxTrackSize.x) and (p.y = FMaxTrackSize.y)) then
    FMaxTrackSizeAssigned := (p.x <> 0) or (p.y <> 0);

  FMaxTrackSize := p;
  UpdateParentSize;
end;

procedure TDSMinMax.SetMinTrackSize(const p: TPoint);
begin
  if not ((p.x = FMinTrackSize.x) and (p.y = FMinTrackSize.y)) then
    FMinTrackSizeAssigned := (p.x <> 0) or (p.y <> 0);

  FMinTrackSize := p;
  UpdateParentSize;
end;

procedure TDSMinMax.UnhookForm;
begin
  { Undo what Hookform did... reset the window procedure and F